mod my;
use std::fmt; // 导入 `fmt` 模块。

// 定义一个包含单个 `Vec` 的结构体 `List`。
struct List(Vec<i32>);

impl fmt::Display for List {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // 使用元组的下标获取值，并创建一个 `vec` 的引用。
        let vec = &self.0;

        write!(f, "[")?;

        // 使用 `v` 对 `vec` 进行迭代，并用 `count` 记录迭代次数。
        for (count, v) in vec.iter().enumerate() {
            // 对每个元素（第一个元素除外）加上逗号。
            // 使用 `?` 或 `try!` 来返回错误。
            if count != 0 { write!(f, ", ")?; }
            write!(f, "{}:{}", v-1,v)?;
        }

        // 加上配对中括号，并返回一个 fmt::Result 值。
        write!(f, "]")
    }
}

fn main() {
    let v = List(vec![1, 2, 3]);
    println!("{}", v);
    my::function();

    my::indirect_access();

    my::nested::function();
    for city in[
        my::myfmt::City { name: "Dublin", lat: 53.347778, lon: -6.259722 },
        my::myfmt::City { name: "Oslo", lat: 59.95, lon: 10.75 },
        my::myfmt::City { name: "Vancouver", lat: 49.25, lon: -123.1 },
    ].iter(){
        println!("{}",*city)
    }
    for color in[
        my::myfmt::Color { red: 128, green: 255, blue: 90 },
        my::myfmt::Color { red: 0, green: 3, blue: 254 },
        my::myfmt::Color { red: 0, green: 0, blue: 0 },
    ].iter(){
        println!("{}",*color)
    }

    println!("1 + 2 = {}", 1u32 + 2);

    // 整数相减
    println!("1 - 2 = {}", 1i32 - 2);
    // 试一试 ^ 尝试将 `1i32` 改为 `1u32`，体会为什么类型声明这么重要

    // 短路求值的布尔逻辑
    println!("true AND false is {}", true && false);
    println!("true OR false is {}", true || false);
    println!("NOT true is {}", !true);

    // 位运算
    println!("0011 AND 0101 is {:08b}", 0b0011u32 & 0b0101);
    println!("0011 OR 0101 is {:016b}", 0b0011u32 | 0b0101);
    println!("0011 XOR 0101 is {:032b}", 0b0011u32 ^ 0b0101);
    println!("1 << 5 is {:010b}", 1u32 << 5);
    println!("0x80 >> 2 is 0x{:X}", 0x80u32 >> 2);

    println!("One million is written as {}", 1_000_000u32);

    let pair = (1, true);
    println!("pair is {:?}", pair);

    println!("the reversed pair is {:?}", my::pair::reverse(pair));

    let matrix1 = my::pair::matrix2(1.1, 1.2, 2.1, 2.2);
    println!("{:}", matrix1);
    println!("slice #############################################");
    let mut vec = Vec::with_capacity(10); // 预分配容量
    vec.extend([1, 2, 3]);
    let slice = &vec[..]; // 初始切片

    // 添加元素（无需立即扩容）
    vec.push(4);
    vec.push(5);
    vec.extend([6, 7,8,9,10]);
    vec[8] = 100;
    let mut ve2: Vec<i32> =  Vec::with_capacity(100);
    ve2.push(200);
    println!("{:?}", ve2); // 输出: [1, 2, 3, 40, 5]

    struct Foo { x: (u32, u32), y: u32 }

    // 解构结构体的成员
    let foo = Foo { x: (1, 2), y: 3 };
    let Foo { x: (a, b), y } = foo;

    println!("a = {}, b = {},  y = {} ", a, b, y);

    // 可以解构结构体并重命名变量，成员顺序并不重要

    let Foo { y: i, x: j } = foo;
    println!("i = {:?}, j = {:?}", i, j);

    // 也可以忽略某些变量
    let Foo { y, .. } = foo;
    println!("y = {}", y);
}